/**
 * 监控页面共享工具方法
 */

/**
 * 获取能耗类型名称
 * @param {string|number} type 能耗类型
 * @returns {string} 类型名称
 */
export function getEnergyTypeName(type) {
  // 支持数字编码和英文名称
  const typeMap = {
    // 数字编码
    '1': '电力',
    '2': '燃气',
    '3': '水',
    '4': '蒸汽',
    '5': '其他',
    // 英文名称
    'electric': '电力',
    'electricity': '电力',
    'power': '电力',
    'gas': '燃气',
    'natural_gas': '燃气',
    'water': '水',
    'steam': '蒸汽',
    'other': '其他',
    'others': '其他'
  };
  return typeMap[String(type)] || type || '-';
}

/**
 * 获取能耗类型标签样式
 * @param {string|number} type 能耗类型
 * @returns {string} 标签类型
 */
export function getEnergyTypeTag(type) {
  const tagMap = {
    // 数字编码
    '1': 'primary',   // 电力
    '2': 'warning',   // 燃气
    '3': 'info',      // 水
    '4': 'success',   // 蒸汽
    '5': 'default',   // 其他
    // 英文名称
    'electric': 'primary',
    'electricity': 'primary',
    'power': 'primary',
    'gas': 'warning',
    'natural_gas': 'warning',
    'water': 'info',
    'steam': 'success',
    'other': 'default',
    'others': 'default'
  };
  return tagMap[String(type)] || 'default';
}

/**
 * 获取设备状态名称
 * @param {string} status 状态码
 * @returns {string} 状态名称
 */
export function getStatusName(status) {
  const statusMap = {
    '0': '正常',
    '1': '告警',
    '2': '故障',
    '3': '离线'
  };
  return statusMap[status] || '未知';
}

/**
 * 获取设备状态标签样式
 * @param {string} status 状态码
 * @returns {string} 标签类型
 */
export function getStatusTag(status) {
  const tagMap = {
    '0': 'success',
    '1': 'warning',
    '2': 'danger',
    '3': 'info'
  };
  return tagMap[status] || 'default';
}

/**
 * 格式化数值
 * @param {number|string} value 数值
 * @param {number} precision 精度
 * @returns {string} 格式化后的数值
 */
export function formatValue(value, precision = 2) {
  if (value === null || value === undefined || value === '') {
    return '-';
  }
  const num = parseFloat(value);
  return isNaN(num) ? '-' : num.toFixed(precision);
}

/**
 * 获取指标状态
 * @param {string} key 指标类型
 * @param {number} value 指标值
 * @returns {string} 状态
 */
export function getMetricStatus(key, value) {
  const thresholds = {
    power: { warning: 80, danger: 95 },
    voltage: { min: 200, max: 240 },
    current: { warning: 400, danger: 480 },
    temperature: { warning: 60, danger: 75 }
  };

  const threshold = thresholds[key];
  if (!threshold) return 'normal';

  if (key === 'voltage') {
    if (value < threshold.min || value > threshold.max) return 'danger';
    if (value < threshold.min + 10 || value > threshold.max - 10) return 'warning';
  } else {
    if (value >= threshold.danger) return 'danger';
    if (value >= threshold.warning) return 'warning';
  }

  return 'normal';
}

/**
 * 获取数值样式类
 * @param {string} type 指标类型
 * @param {number} value 指标值
 * @returns {object} 样式类对象
 */
export function getValueClass(type, value) {
  const num = parseFloat(value);
  if (isNaN(num)) return '';

  const status = getMetricStatus(type, num);
  return {
    'value-normal': status === 'normal',
    'value-warning': status === 'warning',
    'value-danger': status === 'danger'
  };
}

/**
 * 计算平均数据
 * @param {Array} dataList 数据列表
 * @returns {object|null} 平均数据
 */
export function calculateAverageData(dataList) {
  if (!dataList || dataList.length === 0) return null;

  const validData = dataList.filter(item => item.data);
  if (validData.length === 0) return null;

  const sum = validData.reduce((acc, item) => {
    const data = item.data;
    return {
      power: (acc.power || 0) + (data.power || 0),
      voltage: (acc.voltage || 0) + (data.voltage || 0),
      current: (acc.current || 0) + (data.current || 0),
      temperature: (acc.temperature || 0) + (data.temperature || 0)
    };
  }, {});

  const count = validData.length;
  return {
    power: sum.power / count,
    voltage: sum.voltage / count,
    current: sum.current / count,
    temperature: sum.temperature / count
  };
}

/**
 * 格式化日期为后端支持的格式
 * @param {Date} date 日期对象
 * @returns {string} 格式化后的日期字符串
 */
function formatDateForBackend(date) {
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const day = String(date.getDate()).padStart(2, '0');
  const hours = String(date.getHours()).padStart(2, '0');
  const minutes = String(date.getMinutes()).padStart(2, '0');
  const seconds = String(date.getSeconds()).padStart(2, '0');

  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
}

/**
 * 获取图表参数
 * @param {string} chartTimeRange 时间范围
 * @param {object} queryParams 查询参数
 * @param {Array} dateRange 日期范围
 * @returns {object} 图表参数
 */
export function getChartParams(chartTimeRange, queryParams, dateRange) {
  const params = {
    deviceId: queryParams.deviceId,
    energyType: queryParams.energyType
  };

  // 根据时间范围设置参数
  const now = new Date();
  let startTime, endTime = now;

  switch (chartTimeRange) {
    case '1h':
      // 最近1小时的数据
      startTime = new Date(now.getTime() - 1 * 60 * 60 * 1000);
      params.interval = '5m';  // 5分钟间隔
      break;
    case '6h':
      // 最近6小时的数据
      startTime = new Date(now.getTime() - 6 * 60 * 60 * 1000);
      params.interval = '30m';  // 30分钟间隔
      break;
    case '24h':
      // 最近24小时的数据
      startTime = new Date(now.getTime() - 24 * 60 * 60 * 1000);
      params.interval = '1h';  // 1小时间隔
      break;
    case '7d':
      // 最近7天的数据
      startTime = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
      params.interval = '1d';  // 1天间隔
      break;
    default:
      if (dateRange && dateRange.length === 2) {
        startTime = new Date(dateRange[0]);
        endTime = new Date(dateRange[1]);
      } else {
        // 默认查询最近30天的数据
        startTime = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
        params.interval = '1d';
      }
  }

  // 使用后端支持的日期格式
  params.startTime = formatDateForBackend(startTime);
  params.endTime = formatDateForBackend(endTime);

  return params;
}

/**
 * 更新实时指标数据
 * @param {Array} realTimeMetrics 实时指标数组
 * @param {object} data 新数据
 * @returns {Array} 更新后的指标数组
 */
export function updateRealTimeMetrics(realTimeMetrics, data) {
  if (!data) return realTimeMetrics;

  const metrics = [
    { key: 'power', index: 0, precision: 2 },
    { key: 'voltage', index: 1, precision: 2 },
    { key: 'current', index: 2, precision: 2 },
    { key: 'temperature', index: 3, precision: 1 }
  ];

  const updatedMetrics = [...realTimeMetrics];

  metrics.forEach(metric => {
    const currentValue = parseFloat(updatedMetrics[metric.index].value) || 0;
    const newValue = parseFloat(data[metric.key]) || 0;

    // 计算趋势
    const trend = currentValue > 0 ? ((newValue - currentValue) / currentValue * 100) : 0;

    updatedMetrics[metric.index] = {
      ...updatedMetrics[metric.index],
      value: newValue.toFixed(metric.precision),
      trend: Math.round(trend * 100) / 100,
      status: getMetricStatus(metric.key, newValue)
    };
  });

  return updatedMetrics;
}

/**
 * 验证设置参数
 * @param {object} settings 设置对象
 * @returns {object} 验证结果
 */
export function validateSettings(settings) {
  const errors = [];

  if (settings.refreshInterval < 1000) {
    errors.push('刷新间隔不能小于1秒');
  }

  if (settings.dataRetentionDays < 1 || settings.dataRetentionDays > 365) {
    errors.push('数据保留天数必须在1-365天之间');
  }

  return {
    isValid: errors.length === 0,
    errors
  };
}
